<!DOCTYPE html>

<html>
  <head>
    <meta charset="utf-8">
    
    <title>numpy.linalg.qr &mdash; NumPy v1.18 Manual</title>
    
    <link rel="stylesheet" type="text/css" href="../../_static/css/spc-bootstrap.css">
    <link rel="stylesheet" type="text/css" href="../../_static/css/spc-extend.css">
    <link rel="stylesheet" href="../../_static/scipy.css" type="text/css" >
    <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" >
    <link rel="stylesheet" href="../../_static/graphviz.css" type="text/css" >
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '../../',
        VERSION:     '1.18.1',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  false
      };
    </script>
    <script type="text/javascript" src="../../_static/jquery.js"></script>
    <script type="text/javascript" src="../../_static/underscore.js"></script>
    <script type="text/javascript" src="../../_static/doctools.js"></script>
    <script type="text/javascript" src="../../_static/language_data.js"></script>
    <script type="text/javascript" src="../../_static/js/copybutton.js"></script>
    <link rel="author" title="About these documents" href="../../about.html" >
    <link rel="index" title="Index" href="../../genindex.html" >
    <link rel="search" title="Search" href="../../search.html" >
    <link rel="top" title="NumPy v1.18 Manual" href="../../index.html" >
    <link rel="up" title="Linear algebra (numpy.linalg)" href="../routines.linalg.html" >
    <link rel="next" title="numpy.linalg.svd" href="numpy.linalg.svd.html" >
    <link rel="prev" title="numpy.linalg.cholesky" href="numpy.linalg.cholesky.html" > 
  </head>
  <body>
<div class="container">
  <div class="top-scipy-org-logo-header" style="background-color: #a2bae8;">
    <a href="../../index.html">
      <img border=0 alt="NumPy" src="../../_static/numpy_logo.png"></a>
    </div>
  </div>
</div>


    <div class="container">
      <div class="main">
        
	<div class="row-fluid">
	  <div class="span12">
	    <div class="spc-navbar">
              
    <ul class="nav nav-pills pull-left">
        <li class="active"><a href="https://numpy.org/">NumPy.org</a></li>
        <li class="active"><a href="https://numpy.org/doc">Docs</a></li>
        
        <li class="active"><a href="../../index.html">NumPy v1.18 Manual</a></li>
        

          <li class="active"><a href="../index.html" >NumPy Reference</a></li>
          <li class="active"><a href="../routines.html" >Routines</a></li>
          <li class="active"><a href="../routines.linalg.html" accesskey="U">Linear algebra (<code class="xref py py-mod docutils literal notranslate"><span class="pre">numpy.linalg</span></code>)</a></li> 
    </ul>
              
              
    <ul class="nav nav-pills pull-right">
      <li class="active">
        <a href="../../genindex.html" title="General Index"
           accesskey="I">index</a>
      </li>
      <li class="active">
        <a href="numpy.linalg.svd.html" title="numpy.linalg.svd"
           accesskey="N">next</a>
      </li>
      <li class="active">
        <a href="numpy.linalg.cholesky.html" title="numpy.linalg.cholesky"
           accesskey="P">previous</a>
      </li>
    </ul>
              
	    </div>
	  </div>
	</div>
        

	<div class="row-fluid">
      <div class="spc-rightsidebar span3">
        <div class="sphinxsidebarwrapper">
  <h4>Previous topic</h4>
  <p class="topless"><a href="numpy.linalg.cholesky.html"
                        title="previous chapter">numpy.linalg.cholesky</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="numpy.linalg.svd.html"
                        title="next chapter">numpy.linalg.svd</a></p>
<div id="searchbox" style="display: none" role="search">
  <h4>Quick search</h4>
    <div>
    <form class="search" action="../../search.html" method="get">
      <input type="text" style="width: inherit;" name="q" />
      <input type="submit" value="search" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
    </div>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
          <div class="span9">
            
        <div class="bodywrapper">
          <div class="body" id="spc-section-body">
            
  <div class="section" id="numpy-linalg-qr">
<h1>numpy.linalg.qr<a class="headerlink" href="#numpy-linalg-qr" title="Permalink to this headline">¶</a></h1>
<dl class="function">
<dt id="numpy.linalg.qr">
<code class="sig-prename descclassname">numpy.linalg.</code><code class="sig-name descname">qr</code><span class="sig-paren">(</span><em class="sig-param">a</em>, <em class="sig-param">mode='reduced'</em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/numpy/numpy/blob/v1.18.1/numpy/linalg/linalg.py#L765-L969"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numpy.linalg.qr" title="Permalink to this definition">¶</a></dt>
<dd><p>Compute the qr factorization of a matrix.</p>
<p>Factor the matrix <em class="xref py py-obj">a</em> as <em>qr</em>, where <em class="xref py py-obj">q</em> is orthonormal and <em class="xref py py-obj">r</em> is
upper-triangular.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><dl>
<dt><strong>a</strong><span class="classifier">array_like, shape (M, N)</span></dt><dd><p>Matrix to be factored.</p>
</dd>
<dt><strong>mode</strong><span class="classifier">{‘reduced’, ‘complete’, ‘r’, ‘raw’}, optional</span></dt><dd><p>If K = min(M, N), then</p>
<ul class="simple">
<li><p>‘reduced’  : returns q, r with dimensions (M, K), (K, N) (default)</p></li>
<li><p>‘complete’ : returns q, r with dimensions (M, M), (M, N)</p></li>
<li><p>‘r’        : returns r only with dimensions (K, N)</p></li>
<li><p>‘raw’      : returns h, tau with dimensions (N, M), (K,)</p></li>
</ul>
<p>The options ‘reduced’, ‘complete, and ‘raw’ are new in numpy 1.8,
see the notes for more information. The default is ‘reduced’, and to
maintain backward compatibility with earlier versions of numpy both
it and the old default ‘full’ can be omitted. Note that array h
returned in ‘raw’ mode is transposed for calling Fortran. The
‘economic’ mode is deprecated.  The modes ‘full’ and ‘economic’ may
be passed using only the first letter for backwards compatibility,
but all others must be spelled out. See the Notes for more
explanation.</p>
</dd>
</dl>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><dl class="simple">
<dt><strong>q</strong><span class="classifier">ndarray of float or complex, optional</span></dt><dd><p>A matrix with orthonormal columns. When mode = ‘complete’ the
result is an orthogonal/unitary matrix depending on whether or not
a is real/complex. The determinant may be either +/- 1 in that
case.</p>
</dd>
<dt><strong>r</strong><span class="classifier">ndarray of float or complex, optional</span></dt><dd><p>The upper-triangular matrix.</p>
</dd>
<dt><strong>(h, tau)</strong><span class="classifier">ndarrays of np.double or np.cdouble, optional</span></dt><dd><p>The array h contains the Householder reflectors that generate q
along with r. The tau array contains scaling factors for the
reflectors. In the deprecated  ‘economic’ mode only h is returned.</p>
</dd>
</dl>
</dd>
<dt class="field-odd">Raises</dt>
<dd class="field-odd"><dl class="simple">
<dt><strong>LinAlgError</strong></dt><dd><p>If factoring fails.</p>
</dd>
</dl>
</dd>
</dl>
<p class="rubric">Notes</p>
<p>This is an interface to the LAPACK routines <code class="docutils literal notranslate"><span class="pre">dgeqrf</span></code>, <code class="docutils literal notranslate"><span class="pre">zgeqrf</span></code>,
<code class="docutils literal notranslate"><span class="pre">dorgqr</span></code>, and <code class="docutils literal notranslate"><span class="pre">zungqr</span></code>.</p>
<p>For more information on the qr factorization, see for example:
<a class="reference external" href="https://en.wikipedia.org/wiki/QR_factorization">https://en.wikipedia.org/wiki/QR_factorization</a></p>
<p>Subclasses of <em class="xref py py-obj">ndarray</em> are preserved except for the ‘raw’ mode. So if
<em class="xref py py-obj">a</em> is of type <em class="xref py py-obj">matrix</em>, all the return values will be matrices too.</p>
<p>New ‘reduced’, ‘complete’, and ‘raw’ options for mode were added in
NumPy 1.8.0 and the old option ‘full’ was made an alias of ‘reduced’.  In
addition the options ‘full’ and ‘economic’ were deprecated.  Because
‘full’ was the previous default and ‘reduced’ is the new default,
backward compatibility can be maintained by letting <em class="xref py py-obj">mode</em> default.
The ‘raw’ option was added so that LAPACK routines that can multiply
arrays by q using the Householder reflectors can be used. Note that in
this case the returned arrays are of type np.double or np.cdouble and
the h array is transposed to be FORTRAN compatible.  No routines using
the ‘raw’ return are currently exposed by numpy, but some are available
in lapack_lite and just await the necessary work.</p>
<p class="rubric">Examples</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">random</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">9</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">q</span><span class="p">,</span> <span class="n">r</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linalg</span><span class="o">.</span><span class="n">qr</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="n">r</span><span class="p">))</span>  <span class="c1"># a does equal qr</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">r2</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linalg</span><span class="o">.</span><span class="n">qr</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;r&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">r2</span><span class="p">)</span>  <span class="c1"># mode=&#39;r&#39; returns the same r as mode=&#39;full&#39;</span>
<span class="go">True</span>
</pre></div>
</div>
<p>Example illustrating a common use of <a class="reference internal" href="#numpy.linalg.qr" title="numpy.linalg.qr"><code class="xref py py-obj docutils literal notranslate"><span class="pre">qr</span></code></a>: solving of least squares
problems</p>
<p>What are the least-squares-best <em class="xref py py-obj">m</em> and <em class="xref py py-obj">y0</em> in <code class="docutils literal notranslate"><span class="pre">y</span> <span class="pre">=</span> <span class="pre">y0</span> <span class="pre">+</span> <span class="pre">mx</span></code> for
the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points
and you’ll see that it should be y0 = 0, m = 1.)  The answer is provided
by solving the over-determined matrix equation <code class="docutils literal notranslate"><span class="pre">Ax</span> <span class="pre">=</span> <span class="pre">b</span></code>, where:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">A</span> <span class="o">=</span> <span class="n">array</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">]])</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">array</span><span class="p">([[</span><span class="n">y0</span><span class="p">],</span> <span class="p">[</span><span class="n">m</span><span class="p">]])</span>
<span class="n">b</span> <span class="o">=</span> <span class="n">array</span><span class="p">([[</span><span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">]])</span>
</pre></div>
</div>
<p>If A = qr such that q is orthonormal (which is always possible via
Gram-Schmidt), then <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">inv(r)</span> <span class="pre">*</span> <span class="pre">(q.T)</span> <span class="pre">*</span> <span class="pre">b</span></code>.  (In numpy practice,
however, we simply use <a class="reference internal" href="numpy.linalg.lstsq.html#numpy.linalg.lstsq" title="numpy.linalg.lstsq"><code class="xref py py-obj docutils literal notranslate"><span class="pre">lstsq</span></code></a>.)</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span>
<span class="go">array([[0, 1],</span>
<span class="go">       [1, 1],</span>
<span class="go">       [1, 1],</span>
<span class="go">       [2, 1]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">q</span><span class="p">,</span> <span class="n">r</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linalg</span><span class="o">.</span><span class="n">qr</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">q</span><span class="o">.</span><span class="n">T</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">linalg</span><span class="o">.</span><span class="n">inv</span><span class="p">(</span><span class="n">r</span><span class="p">),</span> <span class="n">p</span><span class="p">)</span>
<span class="go">array([  1.1e-16,   1.0e+00])</span>
</pre></div>
</div>
</dd></dl>

</div>


          </div>
        </div>
          </div>
        </div>
      </div>
    </div>

    <div class="container container-navbar-bottom">
      <div class="spc-navbar">
        
      </div>
    </div>
    <div class="container">
    <div class="footer">
    <div class="row-fluid">
    <ul class="inline pull-left">
      <li>
        &copy; Copyright 2008-2019, The SciPy community.
      </li>
      <li>
      Last updated on Feb 20, 2020.
      </li>
      <li>
      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 2.4.2.
      </li>
    </ul>
    </div>
    </div>
    </div>
  </body>
</html>